package com.fzy.common.util;

import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 对字符串操作的工具类
 *
 * @author 冯赵杨
 * @create 2018/7/20
 */
public class StringUtil extends StringUtils {


    /**
     * 判断是字符串是否为空(不包含空格)
     *
     * @param str
     * @return
     * @author 冯赵杨
     * @create 2018/8/31
     */
    public static boolean isNull(String str) {
        return null == str || str.trim().length() == 0;
    }

    /**
     * 判断数组是否为空
     */
    public static boolean isNull(Object[] ary) {
        return null == ary || ary.length == 0;
    }

    /**
     * 判断list集合是否为空
     */
    public static boolean isNull(List<?> list) {
        return null == list || list.size() == 0;
    }

    /**
     * 判断map集合是否为空
     */
    public static boolean isNull(Map<?, ?> map) {
        return null == map || map.isEmpty();
    }

    /**
     * 判断对象的值是否为空
     */
    public static boolean isNull(Object obj) {
        return null == obj || "".equals(obj);
    }

    /**
     * 判断是字符串是否不为空(不包含空格)
     */
    public static boolean isNotNull(String str) {
        return !isNull(str);
    }

    /**
     * 判断数组是否不为空
     */
    public static boolean isNotNull(Object[] ary) {
        return !isNull(ary);
    }

    /**
     * 判断list集合是否不为空
     */
    public static boolean isNotNull(List<?> list) {
        return !isNull(list);
    }

    /**
     * 判断对象的值是否不为空
     */
    public static boolean isNotNull(Map<?, ?> map) {
        return !isNull(map);
    }

    /**
     * 判断对象的值是否不为空
     */
    public static boolean isNotNull(Object obj) {
        return !isNull(obj);
    }

    /**
     * 批量判断是否为空
     *
     * @author 冯赵杨
     * @date 2017年12月21日 下午4:55:19
     */
    public static boolean isNullBatch(String... params) {
        for (String item : params) {
            if (isNull(item)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 批量判断是否不为空
     *
     * @author 冯赵杨
     * @date 2017年12月21日 下午4:55:19
     */
    public static boolean isNotNullBatch(String... params) {
        return !isNullBatch(params);
    }

    /**
     * 将对象的返回的值不能为空
     */
    public static String get(Object obj) {
        if (isNull(obj)) {
            return "";
        }
        return obj.toString();
    }


    /**
     * 若对象为空返回指定的值
     */
    public static String get(Object obj, String defaultStr) {
        if (isNull(obj)) {
            return defaultStr;
        }
        return obj.toString();
    }


    /**
     * 返回整数类型的值 如果为空返回0
     *
     * @param obj
     * @return
     */
    public static Integer getInt(Object obj) {
        if (isNull(obj)) {
            return 0;
        }
        return Integer.valueOf(obj.toString());
    }


    /**
     * 返回整数类型的值 如果为空返回默认值n
     *
     * @param obj
     * @param n
     * @return
     */
    public static Integer getInt(Object obj, Integer n) {
        if (isNull(obj)) {
            return n;
        }
        return Integer.valueOf(obj.toString());
    }

    /**
     * 将对象的返回的值不能为空 去除首尾空格
     */
    public static String trim(String obj) {
        if (null == obj) {
            return "";
        }
        return obj.trim();
    }

    /**
     * list集合转换成字符串
     */
    public static String list2Str(List<?> list) {
        StringBuilder sb = new StringBuilder();

        for (Object o : list) {
            sb.append(o).append(",");
        }

        sb.substring(0, sb.length() - 1);
        return sb.toString();
    }


    /**
     * 提供字符串到字符串数组的转变,转变后的字符串以sStr作为分割符
     */
    public static String[] str2Array(String tStr, String sStr) {
        StringTokenizer st = new StringTokenizer(tStr, sStr);
        String[] reStrs = new String[st.countTokens()];
        int n = 0;
        while (st.hasMoreTokens()) {
            reStrs[n] = st.nextToken();
            n++;
        }
        return reStrs;
    }

    /**
     * 字符串数组到字符串的转变，转变后的字符串没有分割符
     */
    public static String array2Str(String[] arys) {
        return array2Str(arys, ",");
    }

    /**
     * 提供字符串数组到字符串的转变，转变后的字符串以split作为分割符
     */
    public static String array2Str(String[] tStrs, String split) {
        StringBuilder sb = new StringBuilder();
        for (String item : tStrs) {
            sb.append(item).append(split);
        }

        sb.substring(0, sb.length() - 1);
        return sb.toString();
    }

    /**
     * 截取字符串
     *
     * @param src 待截取字符串
     * @param num 截取长度
     * @return 截取后的字符串
     */
    public static String cutStr(String src, int num) {
        if (isNull(src)) {
            return src;
        }
        return src.substring(0, src.length() > num ? num : src.length());
    }

    /**
     * 将String 替换操作，将str1替换为str2
     */
    public static String replace(String str, String str1, String str2) {
        int n;
        String subStr;
        String re;
        if ((n = str.indexOf(str1)) > -1) {
            subStr = str.substring(n + str1.length(), str.length());
            re = str.substring(0, n) + str2 + replace(subStr, str1, str2);
        } else {
            re = str;
        }
        return re;
    }


    /**
     * 替换字符串str中匹配正则表达式reg的字符为空(如:正则表达式 \\%|\\$|\\&|\\<|\\>|| )
     */
    public static String getReplaceStr(String str, String reg) {
        Matcher m = Pattern.compile(reg).matcher(str);
        str = m.replaceAll("");
        return str;
    }


    /**
     * 将字符串tStr以split分割 转换成List
     */
    public static List<String> str2List(String tStr, String split) {
        List<String> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(tStr, split);
        while (st.hasMoreTokens()) {
            list.add(st.nextToken());
        }
        return list;
    }

    /**
     * 计算字符c在ptr字符串中出现的个数
     */
    public static int count(String ptr, char c) {
        int coun = 0, pos = 0;
        while ((pos = ptr.indexOf(c, pos)) != -1) {
            coun++;
            pos++;
        }
        return coun;
    }

    /**
     * 判断一个字符是否是Ascill字符还是其它字符（如汉，日，韩文字符）
     */
    public static boolean isLetter(char c) {
        int k = 0x80;
        return c / k == 0;
    }

    /**
     * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
     */
    public static int length(String s) {
        char[] c = s.toCharArray();
        int len = 0;
        for (char i : c) {
            len++;
            if (!isLetter(i)) {
                len++;
            }
        }
        return len;
    }

    /**
     * 字符串以指定长度进行切割，结果放入Vector对象中
     */
    public Vector<String> str2Vect(String tStr, int nleng) {
        int strLength = tStr.length();
        int ndiv = strLength / nleng;
        Vector<String> reVect = new Vector<>();
        if (strLength % nleng == 0) {
            ndiv--;
        }
        for (int i = 0; i < (ndiv); i++) {
            reVect.add(tStr.substring(i * nleng, (i + 1) * nleng));
        }
        reVect.add(tStr.substring(ndiv * nleng, strLength));
        return reVect;
    }

    /**
     * 提供字符串到Vector的转变
     */
    public static Vector<String> str2Vect(String tStr, String sStr) {
        Vector<String> vector = new Vector<>();
        StringTokenizer st = new StringTokenizer(tStr, sStr);
        while (st.hasMoreTokens()) {
            vector.add(st.nextToken());
        }
        return vector;
    }

    /**
     * 提供Vector到字符串的转变，转变后的字符串以split作为分割符
     */
    public static String vect2Str(Vector<?> tVect, String split) {
        StringBuilder sb = new StringBuilder();

        for (Object item : tVect) {
            sb.append(item).append(split);
        }

        sb.substring(0, sb.length() - 1);

        return sb.toString();
    }

    /**
     * 提供Vector到字符串的转变
     */
    public static String vect2Str(Vector<?> tVect) {
        return vect2Str(tVect, ",");
    }


    /**
     * 校验value是否在数组里
     *
     * @author 冯赵杨
     * @date 2017年5月22日 下午3:46:55
     */
    public static boolean validScope(Object[] obj, Object value) {
        if (value instanceof String && obj instanceof String[]) {
            for (Object i : obj) {
                if (i.equals(value)) {
                    return true;
                }
            }
        }

        if (value instanceof Integer && obj instanceof Integer[]) {
            for (Object i : obj) {
                if (i == value) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * 将元数据前补零，补后的总长度为指定的长度，以字符串的形式返回
     *
     * @author 冯赵杨
     * @date 2017年3月13日 上午10:35:44
     */
    public static String frontCompWithZore(int num, int formatLength) {
        return String.format("%0" + formatLength + "d", num);
    }


    public static String join(String[] array, String separator) {
        StringBuilder sb = new StringBuilder(1024);
        boolean first = true;

        for (String item : array) {
            if (first) {
                first = false;
            } else {
                sb.append(separator);
            }

            sb.append(item);
        }

        return sb.toString();
    }

    public static String join(Collection<String> list, String separator) {
        StringBuilder sb = new StringBuilder(1024);
        boolean first = true;

        for (String item : list) {
            if (first) {
                first = false;
            } else {
                sb.append(separator);
            }

            sb.append(item);
        }

        return sb.toString();
    }

    public static String normalizeSpace(String str) {
        int len = str.length();
        StringBuilder sb = new StringBuilder(len);
        boolean space = false;

        for (int i = 0; i < len; i++) {
            char ch = str.charAt(i);

            switch (ch) {
                case ' ':
                case '\t':
                case '\r':
                case '\n':
                    space = true;
                    break;
                default:
                    if (space) {
                        sb.append(' ');
                        space = false;
                    }

                    sb.append(ch);
            }
        }

        return sb.toString();
    }

    public static String trimAll(String str) {
        if (str == null) {
            return str;
        }

        int len = str.length();
        StringBuilder sb = new StringBuilder(len);

        for (int i = 0; i < len; i++) {
            char ch = str.charAt(i);

            switch (ch) {
                case ' ':
                case '\t':
                case '\r':
                case '\n':
                    break;
                default:
                    sb.append(ch);
            }
        }

        return sb.toString();
    }

}
